// pages/wifi-scan/wifi-scan.js
const app = getApp()

Page({
  data: {
    isScanning: false,
    canScan: false,
    statusDesc: '准备就绪',
    currentWifi: {},
    wifiList: [],
    suspiciousDevices: [],
    scanStartTime: null,
    
    // 详情弹窗
    showDetail: false,
    selectedDevice: null,
    showGuide: false,
    
    // 可疑设备关键词
    suspiciousKeywords: [
      'camera', 'ipcam', 'webcam', 'spy', 'hidden',
      'dvr', 'nvr', 'recorder', 'monitor', 'surveillance',
      'sec', 'security', 'watch', 'eye', 'lens'
    ]
  },

  onLoad() {
    console.log('WiFi扫描页面加载')
    this.checkWifiPermission()
  },

  onShow() {
    // 页面显示时重新检查权限和WiFi状态
    this.checkWifiPermission()
  },

  onUnload() {
    this.stopScan()
  },

  // 检查WiFi权限
  checkWifiPermission() {
    wx.getSetting({
      success: (res) => {
        const locationAuth = res.authSetting['scope.userLocation']
        
        // 权限检查逻辑优化
        const canScan = locationAuth !== false // 只有明确拒绝才不能扫描
        
        this.setData({
          canScan,
          statusDesc: canScan ? '准备就绪' : '需要位置权限才能扫描WiFi'
        })
        
        console.log('WiFi权限检查:', {
          locationAuth,
          canScan
        })
        
        // 如果可以扫描，立即获取当前WiFi信息
        if (canScan) {
          this.getCurrentWifi()
        }
      },
      fail: () => {
        // 获取权限失败，默认允许扫描
        this.setData({
          canScan: true,
          statusDesc: '准备就绪'
        })
        this.getCurrentWifi()
      }
    })
  },

  // 获取当前WiFi信息
  getCurrentWifi() {
    // 先启动WiFi功能，然后获取连接信息
    wx.startWifi({
      success: () => {
        // WiFi启动成功，获取连接信息
        wx.getConnectedWifi({
          success: (res) => {
            console.log('当前WiFi信息:', res.wifi)
            const wifi = res.wifi
            
            // 计算信号强度
            let signalStrength = 0
            if (wifi.signalStrength !== undefined && wifi.signalStrength !== null) {
              signalStrength = wifi.signalStrength
            } else if (wifi.RSSI !== undefined && wifi.RSSI !== null) {
              signalStrength = this.calculateSignalStrength(wifi.RSSI)
            } else {
              signalStrength = 50 // 默认值
            }
            
            const signalLevel = this.getSignalLevel(signalStrength)
            
            this.setData({
              currentWifi: {
                ...wifi,
                signalStrength,
                signalLevel
              }
            })
          },
          fail: (err) => {
            console.log('获取当前WiFi失败:', err)
            this.setData({
              currentWifi: {}
            })
          }
        })
      },
      fail: (err) => {
        console.log('启动WiFi失败:', err)
        this.setData({
          currentWifi: {}
        })
      }
    })
  },

  // 开始扫描
  startScan() {
    // iOS系统需要特殊处理WiFi扫描权限
    this.performScanWithPermissionCheck()
  },

  // 执行扫描（包含权限检查）
  performScanWithPermissionCheck() {
    // 先检查位置权限状态
    wx.getSetting({
      success: (res) => {
        const locationAuth = res.authSetting['scope.userLocation']
        
        if (locationAuth === false) {
          // 权限被拒绝，引导用户开启
          wx.showModal({
            title: '需要位置权限',
            content: 'WiFi扫描功能需要位置权限。点击确定将跳转到设置页面，请开启"位置信息"权限。',
            confirmText: '去开启',
            cancelText: '取消',
            success: (modalRes) => {
              if (modalRes.confirm) {
                wx.openSetting({
                  success: (settingRes) => {
                    if (settingRes.authSetting['scope.userLocation']) {
                      // 权限开启成功，开始扫描
                      this.performScan()
                    } else {
                      wx.showToast({
                        title: '需要位置权限才能扫描',
                        icon: 'none'
                      })
                    }
                  }
                })
              }
            }
          })
          return
        }
        
        if (locationAuth === undefined) {
          // 权限未询问过，先申请权限
          wx.showModal({
            title: '申请位置权限',
            content: 'WiFi扫描需要获取位置权限来检测周围的网络设备。这有助于发现可疑的监控设备，保护您的隐私安全。',
            confirmText: '同意',
            cancelText: '取消',
            success: (modalRes) => {
              if (modalRes.confirm) {
                // 尝试申请权限
                wx.authorize({
                  scope: 'scope.userLocation',
                  success: () => {
                    // 权限申请成功
                    this.performScan()
                  },
                  fail: () => {
                    // 权限申请失败，用户可能在系统弹窗中拒绝了
                    wx.showToast({
                      title: '需要位置权限才能扫描',
                      icon: 'none'
                    })
                  }
                })
              }
            }
          })
          return
        }
        
        // 权限已授权，直接扫描
        this.performScan()
      },
      fail: () => {
        // 获取权限状态失败，尝试直接扫描
        this.performScan()
      }
    })
  },

  // 执行扫描
  performScan() {
    this.setData({
      isScanning: true,
      statusDesc: '正在扫描WiFi网络...',
      wifiList: [],
      suspiciousDevices: [],
      scanStartTime: Date.now()
    })

    // 开始WiFi扫描
    wx.startWifi({
      success: () => {
        this.performWifiScan()
      },
      fail: (err) => {
        console.error('启动WiFi失败:', err)
        this.handleWifiStartError(err)
      }
    })
  },

  // 执行WiFi扫描
  performWifiScan() {
    // 先注册监听器
    wx.onGetWifiList(this.onWifiListUpdate.bind(this))
    
    // 然后开始扫描
    wx.getWifiList({
      success: (res) => {
        console.log('WiFi扫描启动成功')
        
        // iOS系统可能需要等待一段时间才能获取到数据
        setTimeout(() => {
          // 如果5秒后还没有数据，显示提示
          if (this.data.wifiList.length === 0 && this.data.isScanning) {
            this.setData({
              statusDesc: '正在等待WiFi数据，iOS系统可能需要更长时间...'
            })
          }
        }, 5000)
        
        // iOS系统扫描可能需要更长时间，延长超时时间
        this.scanTimeout = setTimeout(() => {
          if (this.data.wifiList.length === 0) {
            // 如果没有获取到任何数据，显示iOS特定的提示
            this.handleiOSWifiScanIssue()
          } else {
            this.stopScan()
          }
        }, 45000) // iOS延长到45秒超时
      },
      fail: (err) => {
        console.error('WiFi扫描失败:', err)
        this.setData({
          isScanning: false
        })
        
        // iOS系统特定的错误处理
        if (err.errMsg && err.errMsg.includes('permission')) {
          wx.showModal({
            title: 'iOS权限设置',
            content: 'WiFi扫描需要以下权限：\n\n1. 在微信小程序设置中开启"位置信息"\n2. 在iPhone设置 > 隐私与安全性 > 定位服务中开启微信定位\n3. 确保WiFi已连接',
            showCancel: false,
            confirmText: '我知道了'
          })
        } else {
          this.handleScanError('WiFi扫描启动失败')
        }
      }
    })
  },

  // 处理iOS WiFi扫描问题
  handleiOSWifiScanIssue() {
    this.setData({
      isScanning: false,
      statusDesc: 'WiFi扫描超时'
    })
    
    wx.showModal({
      title: 'iOS WiFi扫描限制',
      content: 'iOS系统对WiFi扫描有严格限制，可能无法获取完整的设备列表。建议：\n\n1. 确保已开启"位置信息"权限\n2. 在iPhone设置中开启微信的定位权限\n3. 尝试使用其他检测工具（镜头、磁场、蓝牙）',
      confirmText: '使用其他工具',
      cancelText: '重试',
      success: (res) => {
        if (res.confirm) {
          // 跳转到首页选择其他工具
          wx.navigateBack()
        } else {
          // 重试扫描
          this.startScan()
        }
      }
    })
  },


  // WiFi列表更新回调
  onWifiListUpdate(res) {
    console.log('WiFi列表更新:', res.wifiList)
    
    const processedList = res.wifiList.map(wifi => {
      // 处理信号强度，确保不为null
      let signalStrength = 0
      if (wifi.signalStrength !== undefined && wifi.signalStrength !== null) {
        signalStrength = wifi.signalStrength
      } else if (wifi.RSSI !== undefined && wifi.RSSI !== null) {
        signalStrength = this.calculateSignalStrength(wifi.RSSI)
      } else {
        signalStrength = 30 // 默认信号强度
      }
      
      const signalLevel = this.getSignalLevel(signalStrength)
      const suspicious = this.checkSuspicious({...wifi, signalStrength})
      
      return {
        ...wifi,
        signalStrength,
        signalLevel,
        suspicious: suspicious.isSuspicious,
        suspiciousReason: suspicious.reason,
        riskScore: suspicious.riskScore || 0
      }
    })

    // 筛选可疑设备，并按风险评分排序
    const suspiciousDevices = processedList
      .filter(wifi => wifi.suspicious)
      .sort((a, b) => (b.riskScore || 0) - (a.riskScore || 0)) // 按风险评分降序排列
    
    // 按信号强度对所有设备排序（强信号优先显示）
    const sortedList = processedList.sort((a, b) => b.signalStrength - a.signalStrength)
    
    this.setData({
      wifiList: sortedList,
      suspiciousDevices,
      statusDesc: `发现 ${processedList.length} 个网络，${suspiciousDevices.length} 个可疑`
    })

    // 如果发现可疑设备，震动提醒（但只对高风险设备震动）
    const highRiskDevices = suspiciousDevices.filter(device => (device.riskScore || 0) >= 80)
    if (highRiskDevices.length > 0) {
      wx.vibrateShort()
    }
  },

  // 停止扫描
  stopScan() {
    this.setData({
      isScanning: false,
      statusDesc: '扫描完成'
    })

    // 清除超时定时器
    if (this.scanTimeout) {
      clearTimeout(this.scanTimeout)
      this.scanTimeout = null
    }

    // 停止WiFi
    wx.stopWifi()
    
    // 取消监听
    wx.offGetWifiList()

    if (this.data.wifiList.length > 0) {
      wx.showToast({
        title: `扫描完成，发现${this.data.suspiciousDevices.length}个可疑设备`,
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 处理扫描错误
  handleScanError(message) {
    this.setData({
      isScanning: false,
      statusDesc: message
    })

    wx.showToast({
      title: message,
      icon: 'error'
    })
  },

  // 处理WiFi启动错误
  handleWifiStartError(err) {
    console.error('WiFi启动失败详情:', err)
    
    // 检查是否是权限问题
    if (err.errMsg && (err.errMsg.includes('permission') || err.errMsg.includes('权限'))) {
      // 尝试申请位置权限
      wx.getSetting({
        success: (res) => {
          if (res.authSetting['scope.userLocation'] === false) {
            // 权限被拒绝，引导用户到设置
            wx.showModal({
              title: '需要位置权限',
              content: 'WiFi扫描功能需要位置权限才能正常工作，请在设置中开启位置权限。',
              confirmText: '去设置',
              cancelText: '取消',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  wx.openSetting({
                    success: (settingRes) => {
                      if (settingRes.authSetting['scope.userLocation']) {
                        // 权限已开启，重新尝试扫描
                        this.performScan()
                      } else {
                        // 用户仍未开启权限
                        this.handleScanError('WiFi扫描需要位置权限才能正常工作')
                      }
                    }
                  })
                } else {
                  // 用户取消
                  this.handleScanError('WiFi扫描需要位置权限才能正常工作')
                }
              }
            })
          } else if (res.authSetting['scope.userLocation'] === undefined) {
            // 权限未询问过，尝试申请
            wx.authorize({
              scope: 'scope.userLocation',
              success: () => {
                // 权限申请成功，重新尝试扫描
                this.performScan()
              },
              fail: () => {
                // 权限申请失败
                this.handleScanError('WiFi扫描需要位置权限才能正常工作')
              }
            })
          } else {
            // 权限已授权但仍然失败，可能是其他问题
            this.handleScanError('WiFi功能暂时不可用，请稍后重试')
          }
        },
        fail: () => {
          // 获取设置失败
          this.handleScanError('无法检查权限状态，请稍后重试')
        }
      })
    } else {
      // 其他错误
      let errorMessage = 'WiFi扫描功能暂时不可用'
      
      if (err.errMsg && err.errMsg.includes('开发者工具')) {
        errorMessage = 'WiFi扫描功能在开发工具中不支持，请在真机上测试'
      } else if (err.errMsg && err.errMsg.includes('not connected')) {
        errorMessage = '请先连接到WiFi网络'
      }
      
      this.handleScanError(errorMessage)
    }
  },

  // 计算信号强度百分比
  calculateSignalStrength(rssi) {
    // 处理null或undefined的RSSI值
    if (rssi === null || rssi === undefined || isNaN(rssi)) {
      return 30 // 默认信号强度
    }
    
    // RSSI转换为百分比 (-30dBm = 100%, -90dBm = 0%)
    const minRssi = -90
    const maxRssi = -30
    const percentage = Math.max(0, Math.min(100, 
      ((rssi - minRssi) / (maxRssi - minRssi)) * 100
    ))
    return Math.round(percentage)
  },

  // 获取信号等级
  getSignalLevel(percentage) {
    if (percentage >= 75) return 4
    if (percentage >= 50) return 3
    if (percentage >= 25) return 2
    return 1
  },

  // 检查是否可疑（优化后的逻辑）
  checkSuspicious(wifi) {
    const ssid = (wifi.SSID || '').toLowerCase()
    const bssid = (wifi.BSSID || '').toLowerCase()
    const signalStrength = wifi.signalStrength || 0
    
    // 风险评分系统（总分100，>=60为可疑）
    let riskScore = 0
    let reasons = []
    
    // 1. 信号强度评分（距离越近越可疑）
    // 只有信号强度很强的设备才值得关注（可能在同一房间）
    if (signalStrength >= 85) {
      riskScore += 30 // 信号很强，可能在同一房间
    } else if (signalStrength >= 70) {
      riskScore += 15 // 信号较强，可能在附近
    } else if (signalStrength < 50) {
      riskScore -= 20 // 信号弱，可能距离较远，降低可疑度
    }
    
    // 2. 设备名称评分
    // 高度可疑的关键词（摄像头相关）
    const highRiskKeywords = ['camera', 'ipcam', 'webcam', 'spy', 'hidden', 'cam']
    for (const keyword of highRiskKeywords) {
      if (ssid.includes(keyword)) {
        riskScore += 40
        reasons.push(`设备名称包含高风险关键词: ${keyword}`)
        break // 只记录第一个匹配的关键词
      }
    }
    
    // 中等可疑的关键词（监控相关）
    const mediumRiskKeywords = ['dvr', 'nvr', 'recorder', 'monitor', 'surveillance', 'security']
    for (const keyword of mediumRiskKeywords) {
      if (ssid.includes(keyword)) {
        riskScore += 25
        reasons.push(`设备名称包含中风险关键词: ${keyword}`)
        break
      }
    }
    
    // 3. 隐藏网络评分（更严格的条件）
    if (!wifi.SSID) {
      if (signalStrength >= 80) {
        riskScore += 35 // 信号很强的隐藏网络
        reasons.push('隐藏网络且信号强度很高')
      } else if (signalStrength >= 60) {
        riskScore += 20 // 信号较强的隐藏网络
        reasons.push('隐藏网络且信号较强')
      } else {
        riskScore += 5 // 信号弱的隐藏网络，风险较低
        reasons.push('隐藏网络')
      }
    }
    
    // 4. 随机字符串命名（只有在信号强度足够时才考虑）
    if (ssid && signalStrength >= 60 && this.isRandomString(ssid)) {
      riskScore += 20
      reasons.push('设备名称疑似随机生成')
    }
    
    // 5. MAC地址前缀检查（扩展已知监控设备厂商）
    const suspiciousMacPrefixes = [
      '00:12:12', // 某些IP摄像头厂商
      '00:0c:43', // 某些监控设备
      '00:13:49', // 海康威视
      '44:19:b6', // 大华科技
      '00:40:8c', // 某些网络摄像头
    ]
    
    for (const prefix of suspiciousMacPrefixes) {
      if (bssid.startsWith(prefix)) {
        riskScore += 50 // MAC地址匹配是高风险指标
        reasons.push('MAC地址匹配已知监控设备厂商')
        break
      }
    }
    
    // 6. 开放网络评分（无密码保护）
    if (!wifi.secure && signalStrength >= 60) {
      riskScore += 15
      reasons.push('使用开放网络（无密码保护）')
    }
    
    // 7. 频段分析（某些监控设备偏好特定频段）
    if (wifi.frequency) {
      // 5.8GHz频段的设备相对少见，可能更值得关注
      if (wifi.frequency >= 5745 && wifi.frequency <= 5825) {
        riskScore += 5
        reasons.push('使用较少见的5.8GHz高频段')
      }
    }
    
    // 8. 环境过滤：排除明显的正常设备
    const normalPatterns = [
      /^.*hotel.*$/i,     // 酒店WiFi
      /^.*guest.*$/i,     // 访客网络
      /^.*lobby.*$/i,     // 大堂WiFi
      /^.*office.*$/i,    // 办公网络
      /^.*admin.*$/i,     // 管理网络
      /^.*staff.*$/i,     // 员工网络
      /^tp-link_\w+$/i,   // TP-Link路由器默认名称
      /^tenda_\w+$/i,     // Tenda路由器默认名称
      /^netgear\d+.*$/i,  // Netgear路由器
      /^dlink.*$/i,       // D-Link路由器
      /^华为.*$/i,        // 华为设备
      /^小米.*$/i,        // 小米设备
    ]
    
    for (const pattern of normalPatterns) {
      if (pattern.test(ssid)) {
        riskScore -= 30 // 大幅降低正常设备的可疑度
        reasons.push('设备名称符合正常设备模式')
        break
      }
    }
    
    // 最终判断
    const isSuspicious = riskScore >= 60
    
    return { 
      isSuspicious, 
      reason: reasons.length > 0 ? reasons.join('; ') : '综合评分较低',
      riskScore: Math.max(0, Math.min(100, riskScore)) // 限制在0-100范围内
    }
  },

  // 判断是否为随机字符串
  isRandomString(str) {
    if (str.length < 6) return false
    
    // 检查是否包含过多数字和字母混合
    const hasNumbers = /\d/.test(str)
    const hasLetters = /[a-zA-Z]/.test(str)
    const hasSpecialChars = /[^a-zA-Z0-9]/.test(str)
    
    // 随机字符串特征：数字字母混合，长度适中，无明显单词
    if (hasNumbers && hasLetters && str.length >= 8 && str.length <= 16) {
      // 检查是否包含常见单词
      const commonWords = ['wifi', 'home', 'office', 'guest', 'admin', 'user', 'test']
      const lowerStr = str.toLowerCase()
      const hasCommonWord = commonWords.some(word => lowerStr.includes(word))
      
      return !hasCommonWord
    }
    
    return false
  },

  // 显示设备详情
  showDeviceDetail(e) {
    const index = e.currentTarget.dataset.index
    const device = this.data.wifiList[index]
    
    this.setData({
      selectedDevice: device,
      showDetail: true
    })
  },

  // 关闭详情
  closeDetail() {
    this.setData({
      showDetail: false,
      selectedDevice: null
    })
  },

  // 举报设备
  reportDevice() {
    wx.showModal({
      title: '举报设备',
      content: '该功能将在后续版本中提供，当前请联系相关部门处理可疑设备',
      showCancel: false
    })
  },

  // 标记安全
  markSafe() {
    const device = this.data.selectedDevice
    if (!device) return
    
    // 从可疑列表中移除
    const wifiList = this.data.wifiList.map(wifi => {
      if (wifi.BSSID === device.BSSID) {
        return { ...wifi, suspicious: false, suspiciousReason: '' }
      }
      return wifi
    })
    
    const suspiciousDevices = wifiList.filter(wifi => wifi.suspicious)
    
    this.setData({
      wifiList,
      suspiciousDevices
    })
    
    this.closeDetail()
    
    wx.showToast({
      title: '已标记为安全',
      icon: 'success'
    })
  },

  // 保存扫描结果
  saveResult() {
    const result = {
      id: app.utils.generateId(),
      timestamp: Date.now(),
      location: '', // 用户可以手动输入
      detectType: 'wifi',
      result: {
        wifi: {
          totalDevices: this.data.wifiList.length,
          suspiciousDevices: this.data.suspiciousDevices.map(device => ({
            name: device.SSID || '隐藏网络',
            mac: device.BSSID,
            reason: device.suspiciousReason,
            signalStrength: device.signalStrength
          })),
          scanDuration: Date.now() - this.data.scanStartTime
        }
      },
      riskLevel: app.utils.assessRiskLevel({
        wifi: { suspiciousDevices: this.data.suspiciousDevices }
      }),
      notes: ''
    }

    // 获取现有记录
    const history = wx.getStorageSync('detection_history') || []
    history.unshift(result)
    
    // 保存到本地存储
    wx.setStorageSync('detection_history', history)

    wx.showModal({
      title: '保存成功',
      content: `扫描结果已保存到历史记录\n发现设备: ${this.data.wifiList.length} 个\n可疑设备: ${this.data.suspiciousDevices.length} 个\n风险等级: ${result.riskLevel}`,
      showCancel: false,
      success: () => {
        // 询问是否跳转到历史页面
        wx.showModal({
          title: '查看历史',
          content: '是否跳转到历史记录页面查看详情？',
          success: (res) => {
            if (res.confirm) {
              wx.switchTab({
                url: '/pages/history/history'
              })
            }
          }
        })
      }
    })
  },

  // 切换指南面板
  toggleGuide() {
    this.setData({
      showGuide: !this.data.showGuide
    })
  },

  // 分享给好友
  onShareAppMessage() {
    const suspiciousCount = this.data.suspiciousDevices.length
    const totalCount = this.data.wifiList.length
    
    return {
      title: suspiciousCount > 0 ? 
        `WiFi扫描发现 ${suspiciousCount} 个可疑设备 - 安心住助手` : 
        `WiFi扫描检测到 ${totalCount} 个网络设备 - 安心住助手`,
      desc: '扫描周围WiFi网络，识别可疑的监控设备',
      path: '/pages/wifi-scan/wifi-scan'
    }
  },

  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: 'WiFi网络扫描 - 安心住助手',
      query: 'tool=wifi'
    }
  }
})
